home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / rex.lha / rex / m2c / rex.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  7KB  |  281 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Strings
  8. #include "Strings.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_IO
  12. #include "IO.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_StdIO
  16. #include "StdIO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Scanner
  20. #include "Scanner.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Parser
  24. #include "Parser.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Classes
  28. #include "Classes.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Eval
  32. #include "Eval.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Tree
  36. #include "Tree.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Tree0
  40. #include "Tree0.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Dfa
  44. #include "Dfa.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_GenTabs
  48. #include "GenTabs.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_ScanGen
  52. #include "ScanGen.h"
  53. #endif
  54.  
  55. static struct S_1 {
  56.     CHAR A[127 + 1];
  57. } Argument;
  58. static Strings_tString FileNameS, Path;
  59. static SHORTINT optimize;
  60. static SHORTCARD i, j, n;
  61. static BOOLEAN d, s, r, h, w, g, b;
  62. static CHAR ch;
  63.  
  64.  
  65. void BEGIN_MODULE()
  66. {
  67.   BEGIN_System();
  68.   BEGIN_Strings();
  69.   BEGIN_IO();
  70.   BEGIN_StdIO();
  71.   BEGIN_Scanner();
  72.   BEGIN_Parser();
  73.   BEGIN_Classes();
  74.   BEGIN_Eval();
  75.   BEGIN_Tree();
  76.   BEGIN_Tree0();
  77.   BEGIN_Dfa();
  78.   BEGIN_GenTabs();
  79.   BEGIN_ScanGen();
  80.  
  81.   d = FALSE;
  82.   s = FALSE;
  83.   r = FALSE;
  84.   h = FALSE;
  85.   w = TRUE;
  86.   g = FALSE;
  87.   b = TRUE;
  88.   optimize = 40;
  89.   n = 0;
  90.   ScanGen_Language = ScanGen_Modula;
  91.   Strings_AssignEmpty(&ScanGen_RexLib);
  92.   ScanGen_SourceFile.A[0] = '\0';
  93.   {
  94.     SHORTCARD B_1 = 1, B_2 = GetArgCount() - 1;
  95.  
  96.     if (B_1 <= B_2)
  97.       for (i = B_1;; i += 1) {
  98.         GetArgument((LONGCARD)i, Argument.A, 128L);
  99.         if (Argument.A[0] == '-') {
  100.           if (Argument.A[1] == 'l') {
  101.             Strings_AssignEmpty(&ScanGen_RexLib);
  102.             j = 2;
  103.             for (;;) {
  104.               ch = Argument.A[j];
  105.               if (ch == '\0') {
  106.                 goto EXIT_1;
  107.               }
  108.               Strings_Append(&ScanGen_RexLib, ch);
  109.               INC(j);
  110.             } EXIT_1:;
  111.             Strings_Append(&ScanGen_RexLib, '/');
  112.           } else {
  113.             j = 0;
  114.             for (;;) {
  115.               INC(j);
  116.               ch = Argument.A[j];
  117.               switch (ch) {
  118.               case '\0':;
  119.                 goto EXIT_2;
  120.                 break;
  121.               case '?':;
  122.                 h = TRUE;
  123.                 break;
  124.               case 'h':;
  125.                 h = TRUE;
  126.                 break;
  127.               case 'c':;
  128.                 ScanGen_Language = ScanGen_C;
  129.                 break;
  130.               case 'm':;
  131.                 ScanGen_Language = ScanGen_Modula;
  132.                 break;
  133.               case 'd':;
  134.                 d = TRUE;
  135.                 break;
  136.               case 's':;
  137.                 s = TRUE;
  138.                 break;
  139.               case 'r':;
  140.                 r = TRUE;
  141.                 break;
  142.               case 'a':;
  143.                 d = TRUE;
  144.                 s = TRUE;
  145.                 break;
  146.               case 'i':;
  147.                 Dfa_LastCh = ((CHAR)'\377');
  148.                 break;
  149.               case 'o':;
  150.                 optimize = 16000;
  151.                 break;
  152.               case 'n':;
  153.                 optimize = 0;
  154.                 break;
  155.               case 'w':;
  156.                 w = FALSE;
  157.                 break;
  158.               case 'g':;
  159.                 g = TRUE;
  160.                 break;
  161.               case 'b':;
  162.                 b = FALSE;
  163.                 break;
  164.               case '0':;
  165.               case '1':;
  166.               case '2':;
  167.               case '3':;
  168.               case '4':;
  169.               case '5':;
  170.               case '6':;
  171.               case '7':;
  172.               case '8':;
  173.               case '9':;
  174.                 n = n * 10 + ORD(ch) - ORD('0');
  175.                 break;
  176.               default :
  177.                 break;
  178.               }
  179.             } EXIT_2:;
  180.           }
  181.         } else if (Argument.A[0] == '?') {
  182.           h = TRUE;
  183.         } else {
  184.           j = 0;
  185.           do {
  186.             ch = Argument.A[j];
  187.             ScanGen_SourceFile.A[j] = ch;
  188.             INC(j);
  189.           } while (!(ch == '\0'));
  190.         }
  191.         if (i >= B_2) break;
  192.       }
  193.   }
  194.   if (h) {
  195.     StdIO_WriteS((STRING)"usage: rex [-options] [file]", 28L);
  196.     StdIO_WriteNl();
  197.     StdIO_WriteNl();
  198.     StdIO_WriteS((STRING)" a generate all (= -dsm)", 24L);
  199.     StdIO_WriteNl();
  200.     StdIO_WriteS((STRING)" m generate a lexical analyzer in Modula (default)", 50L);
  201.     StdIO_WriteNl();
  202.     StdIO_WriteS((STRING)" c generate a lexical analyzer in C", 35L);
  203.     StdIO_WriteNl();
  204.     StdIO_WriteS((STRING)" d generate a definition module for the lexical analyzer", 56L);
  205.     StdIO_WriteNl();
  206.     StdIO_WriteS((STRING)" s generate support modules:", 28L);
  207.     StdIO_WriteNl();
  208.     StdIO_WriteS((STRING)"   . a source module for input", 30L);
  209.     StdIO_WriteNl();
  210.     StdIO_WriteS((STRING)"   . a main program to be used as test driver", 45L);
  211.     StdIO_WriteNl();
  212.     StdIO_WriteS((STRING)" r reduce number of generated case/switch labels", 48L);
  213.     StdIO_WriteNl();
  214.     StdIO_WriteS((STRING)" i use ISO 8 bit code (default: ASCII 7 bit code)", 49L);
  215.     StdIO_WriteNl();
  216.     StdIO_WriteS((STRING)" o optimize table size", 22L);
  217.     StdIO_WriteNl();
  218.     StdIO_WriteS((STRING)" n do not optimize table size", 29L);
  219.     StdIO_WriteNl();
  220.     StdIO_WriteS((STRING)" w suppress warnings", 20L);
  221.     StdIO_WriteNl();
  222.     StdIO_WriteS((STRING)" g generate # line directives", 29L);
  223.     StdIO_WriteNl();
  224.     StdIO_WriteS((STRING)" b do not partition character set into blocks", 45L);
  225.     StdIO_WriteNl();
  226.     StdIO_WriteS((STRING)" 1 print statistics about the generated lexical analyzer", 56L);
  227.     StdIO_WriteNl();
  228.     StdIO_WriteS((STRING)" h print help information", 25L);
  229.     StdIO_WriteNl();
  230.     StdIO_WriteS((STRING)" ldir specify the directory dir where rex finds its data files", 62L);
  231.     StdIO_WriteNl();
  232.   } else {
  233.     Strings_ArrayToString(Scanner_ScanTabName.A, 128L, &FileNameS);
  234.     Strings_Assign(&Path, &ScanGen_RexLib);
  235.     Strings_Concatenate(&Path, &FileNameS);
  236.     Strings_Append(&Path, '\0');
  237.     Strings_StringToArray(&Path, Scanner_ScanTabName.A, 128L);
  238.     Strings_ArrayToString(Parser_ParsTabName.A, 129L, &FileNameS);
  239.     Strings_Assign(&Path, &ScanGen_RexLib);
  240.     Strings_Concatenate(&Path, &FileNameS);
  241.     Strings_Append(&Path, '\0');
  242.     Strings_StringToArray(&Path, Parser_ParsTabName.A, 129L);
  243.     Scanner_BeginScanner();
  244.     if (ScanGen_SourceFile.A[0] != '\0') {
  245.       Scanner_BeginFile(ScanGen_SourceFile.A, 128L);
  246.     }
  247.     if (Parser_Parser() == 0) {
  248.       if (n >= 17) {
  249.         Tree0_WriteTree0((System_tFile)IO_StdOutput, Tree0_Tree0Root);
  250.       }
  251.       Eval_BeginEval();
  252.       Classes_ComputeClasses(b);
  253.       Eval_Eval(Tree0_Tree0Root);
  254.       if (n >= 16) {
  255.         Tree0_WriteTree0((System_tFile)IO_StdOutput, Tree0_Tree0Root);
  256.       }
  257.       GenTabs_LeafCount = GenTabs_StartStateCount + Tree0_Tree0Root->U_1.V_8.List.LeafCount;
  258.       GenTabs_NodeCount = Tree0_Tree0Root->U_1.V_8.List.NodeCount;
  259.       GenTabs_Root = Tree0_Tree0Root->U_1.V_8.List.Tree;
  260.       Classes_ReleaseSetMem();
  261.       Tree0_ReleaseTree0Module();
  262.       if (n >= 15) {
  263.         Tree_WriteTree(GenTabs_Root);
  264.       }
  265.       GenTabs_GenerateTables(n, r, w, optimize);
  266.       ScanGen_GenerateScanner(r, w, g);
  267.     } else {
  268.       IO_CloseIO();
  269.       Exit(1L);
  270.     }
  271.   }
  272.   if (d) {
  273.     ScanGen_GenerateInterface();
  274.   }
  275.   if (s) {
  276.     ScanGen_GenerateSupport();
  277.   }
  278.   IO_CloseIO();
  279.   Exit(0L);
  280. }
  281.